package com.dragon.mmochat.model.deal;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;

import com.dragon.mmochat.MmochatConstant;
import com.dragon.mmochat.message.Mmochat_5_31S;
import com.dragon.mmochat.message.Mmochat_7_18S;
import com.dragon.mmochat.model.MmochatSerial;
import com.dragon.mmochat.model.enumType.MmochatDealRoleState;
import com.dragon.mmochat.model.enumType.MmochatDealState;
import com.dragon.mmochat.model.enumType.MmochatObjectType;
import com.dragon.mmochat.model.object.MmochatCommonObject;
import com.dragon.mmochat.model.object.MmochatPackageGrid;
import com.dragon.mmochat.model.role.MmochatPet;
import com.dragon.mmochat.model.role.MmochatPlayer;
import com.dragon.mmochat.service.MmochatDealService;
import com.dragon.mmochat.service.MmochatMainService;
import com.dragon.mmochat.util.MmochatUtil;
import com.skymobi.message.widget.CloseWinTLV;
import com.skymobi.message.widget.CreateMsgBoxTLV;
import com.skymobi.message.widget.CtrlTLVStructureRequest;
import com.skymobi.util.Text;

public class MmochatDeal implements Serializable {
	private static final long serialVersionUID = 5104893140006771254L;
	private static MmochatSerial serial = new MmochatSerial();
	private int id; // 交易号
	private long startTime = System.currentTimeMillis(); // 交易开始时间
	private MmochatDealState dealState = MmochatDealState.交易中;
	private boolean success = false;
	// roleId-->交易临时包裹
	private Map<Integer, MmochatDealPackage> readyTodealMap = new ConcurrentHashMap<Integer, MmochatDealPackage>();// 交易双方的物品

	// roleId-->已交易物品列表
	private Map<Integer, List<MmochatCommonObject>> dealedMap = new ConcurrentHashMap<Integer, List<MmochatCommonObject>>();

	// roleId-->已交易宠物列表
	private Map<Integer, List<MmochatPet>> dealedPetMap = new ConcurrentHashMap<Integer, List<MmochatPet>>();

	public MmochatDeal() {
		id = serial.addAndGetSerialId();
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public long getStartTime() {
		return startTime;
	}

	public void setStartTime(long startTime) {
		this.startTime = startTime;
	}

	public Map<Integer, MmochatDealPackage> getReadyTodealMap() {
		return readyTodealMap;
	}

	public void setReadyTodealMap(Map<Integer, MmochatDealPackage> dealMap) {
		this.readyTodealMap = new ConcurrentHashMap<Integer, MmochatDealPackage>(
				dealMap);
	}

	public boolean addDealer(MmochatPlayer p) {
		if (readyTodealMap.size() >= 2 || p == null) {
			return false;
		}
		MmochatDealPackage myPackage = new MmochatDealPackage();
		myPackage.setRoleId(p.getRoleId());
		readyTodealMap.put(p.getRoleId(), myPackage);
		dealedMap.put(p.getRoleId(), new ArrayList<MmochatCommonObject>());
		dealedPetMap.put(p.getRoleId(), new ArrayList<MmochatPet>());
		p.setDealId(id);
		return true;
	}

	public MmochatDealPackage getTheOtherDealPackage(int roleId) {
		for (Entry<Integer, MmochatDealPackage> entry : readyTodealMap
				.entrySet()) {
			if (entry.getKey() != roleId) {
				return entry.getValue();
			}
		}
		return null;
	}

	public void stopDeal(int requestRoleId) {
		if (dealState == MmochatDealState.交易不可取消
				|| dealState == MmochatDealState.交易完成) {
			return;
		}
		Integer otherRoleId = null;
		for (Entry<Integer, MmochatDealPackage> entry : readyTodealMap
				.entrySet()) {
			int roleId = entry.getKey();
			if (roleId != requestRoleId) {
				// 通知另一方结束交易
				otherRoleId = roleId;
				MmochatPlayer he = MmochatMainService.players.get(roleId);
				if (he != null) {
					Mmochat_7_18S pack1 = new Mmochat_7_18S();
					pack1.setDealId(id);
					MmochatUtil.sendCommonPack(he, pack1);
				}
			}
		}
		failedDeal(requestRoleId, otherRoleId);
	}

	public boolean isAllConfirmed() {
		for (MmochatDealPackage pack : readyTodealMap.values()) {
			if (pack.getDealState() != MmochatDealRoleState.确定交易) {
				return false;
			}
		}
		return true;
	}

	public boolean isSuccess() {
		return success;
	}

	public void setSuccess(boolean success) {
		this.success = success;
	}

	public MmochatDealState getDealState() {
		return dealState;
	}

	public void setDealState(MmochatDealState dealState) {
		this.dealState = dealState;
	}

	// 失败处理：
	// 1、判断状态是否可取消交易或已经交易成功，如果可以取消且交易未完成，则设置状态为完成交易。否则退出。
	// 2、根据[已交易物品列表]中的物品从对方中扣除(如果是不可叠加物品，则按objId进行扣除；
	// 如果是可叠加物品，则按type,num进行扣除，此时交易过去的物品可能仍在对方那里，扣除的是对方原来的物品)；
	// 将[交易临时包裹]中的物品归还给本方(如果是不可叠加物品，则直接归还；
	// 如果是可叠加物品，则复制一份，生成新的objId，再行归还)。
	// 3、将[已交易物品列表]中的宠物，从对方中扣除，增加到本方中；
	// 4、必需先交易的后归还，后交易的先归还；
	// 5、设置双方的交易ID为未交易状态ID
	// firstDealRoleId:先交易的玩家的roleId; 如果尚未开始交易，则此项为null
	// secondDealRoleId: 后交易的玩家的roleId；如果尚未开始交易，则此项为null
	public void failedDeal(Integer firstDealRoleId, Integer secondDealRoleId) {
		// 如果交易不可取消或交易已完成，则不处理
		if (dealState == MmochatDealState.交易不可取消
				|| dealState == MmochatDealState.交易完成) {
			return;
		}
		synchronized (this) {
			if (dealState == MmochatDealState.交易不可取消
					|| dealState == MmochatDealState.交易完成) {
				return;
			}
			dealState = MmochatDealState.交易完成;
		}
		// 先交易的后还，后交易的先还
		MmochatPlayer firstMan = null;
		MmochatPlayer sendMan = null;

		if (firstDealRoleId != null) {
			firstMan = MmochatMainService.getRoleFromBuffer(firstDealRoleId);
		}
		if (secondDealRoleId != null) {
			sendMan = MmochatMainService.getRoleFromBuffer(secondDealRoleId);
		}

		// 2、根据[已交易物品列表]中的物品从对方中扣除(如果是不可叠加物品，则按objId进行扣除；
		// 如果是可叠加物品，则按type,num进行扣除，此时交易过去的物品可能仍在对方那里，扣除的是对方原来的物品)；
		// 将[交易临时包裹]中的物品归还给本方(如果是不可叠加物品，则直接归还；
		// 如果是可叠加物品，则复制一份，生成新的objId，再行归还)。
		// 4、必需先交易的后归还，后交易的先归还；
		// secondDealRoleId后给出物品，故先归还secondDealRoleId的已交易物品
		// 注意：要先归还双方的已交易物品，再归还交易临时包裹中的物品
		if (firstMan != null && sendMan != null) {
			// 第二人的已交易物品列表
			List<MmochatCommonObject> hisDealedMap = dealedMap
					.get(secondDealRoleId);

			// 从对方中扣除第二人已交易的物品列表
			// 根据[已交易物品列表]中的物品从对方中扣除(如果是不可叠加物品，则按objId进行扣除；
			// 如果是可叠加物品，则按type,num进行扣除，此时交易过去的物品可能仍在对方那里，扣除的是对方原来的物品)
			if (hisDealedMap != null) {
				for (MmochatCommonObject obj : hisDealedMap) {
					if (obj != null && obj.getOverlapNum() > 0) {
						if (!obj.isCanOverlap()) {
							firstMan.delPackageObjById(obj.getId());
						} else {
							firstMan.delPackageCanDealObj(obj.getType(), obj
									.getOverlapNum());
						}
					}
				}
			}

			// 第一人的已交易物品列表
			hisDealedMap = dealedMap.get(firstDealRoleId);

			// 从对方中扣除第一人已交易的物品列表
			// 根据[已交易物品列表]中的物品从对方中扣除(如果是不可叠加物品，则按objId进行扣除；
			// 如果是可叠加物品，则按type,num进行扣除，此时交易过去的物品可能仍在对方那里，扣除的是对方原来的物品)
			if (hisDealedMap != null) {
				for (MmochatCommonObject obj : hisDealedMap) {
					if (obj != null && obj.getOverlapNum() > 0) {
						if (!obj.isCanOverlap()) {
							sendMan.delPackageObjById(obj.getId());
						} else {
							sendMan.delPackageCanDealObj(obj.getType(), obj
									.getOverlapNum());
						}
					}
				}
			}

			// 返还第二人的交易临时包裹
			MmochatDealPackage myDealPack = readyTodealMap
					.get(secondDealRoleId);

			// 将[交易临时包裹]中的物品归还给本方(如果是不可叠加物品，则直接归还；
			// 如果是可叠加物品，则复制一份，生成新的objId，再行归还)。
			if (myDealPack != null) {
				for (MmochatPackageGrid grid : myDealPack
						.getMyDealPackageGrids().values()) {
					if (grid == null) {
						continue;
					}
					MmochatCommonObject obj = grid.getObject();
					if (obj != null && obj.getOverlapNum() > 0) {
						if (obj.getObjectType() != MmochatObjectType.宠物) {
							if (!obj.isCanOverlap()) {
								sendMan.addObjectToPackage(obj);
							} else {
								MmochatCommonObject objCopy = obj
										.getCloneWithNewId();
								sendMan.addObjectToPackage(objCopy);
							}
						}
					}
				}
			}

			// 返还第一人的交易临时包裹
			myDealPack = readyTodealMap.get(firstDealRoleId);

			// 将[交易临时包裹]中的物品归还给本方(如果是不可叠加物品，则直接归还；
			// 如果是可叠加物品，则复制一份，生成新的objId，再行归还)。
			if (myDealPack != null) {
				for (MmochatPackageGrid grid : myDealPack
						.getMyDealPackageGrids().values()) {
					if (grid == null) {
						continue;
					}
					MmochatCommonObject obj = grid.getObject();
					if (obj != null && obj.getOverlapNum() > 0) {
						if (obj.getObjectType() != MmochatObjectType.宠物) {
							if (!obj.isCanOverlap()) {
								firstMan.addObjectToPackage(obj);
							} else {
								MmochatCommonObject objCopy = obj
										.getCloneWithNewId();
								firstMan.addObjectToPackage(objCopy);
							}
						}
					}
				}
			}
		}

		// 3、将[已交易物品列表]中的宠物，从对方中扣除，增加到本方中；
		// 4、必需先交易的后归还，后交易的先归还；
		// 注意：必需先执行扣除操作，再执行增加操作，否则可能没有空位
		if (firstMan != null && sendMan != null) {
			List<MmochatPet> hisPets = dealedPetMap.get(secondDealRoleId);
			if (hisPets != null) {
				for (MmochatPet pet : hisPets) {
					if (pet != null) {
						firstMan.delPet(pet.getId());
						// sendMan.addPet(pet);
					}
				}
			}

			List<MmochatPet> myPets = dealedPetMap.get(firstDealRoleId);
			if (myPets != null) {
				for (MmochatPet pet : myPets) {
					if (pet != null) {
						sendMan.delPet(pet.getId());
						// firstMan.addPet(pet);
					}
				}
			}

			if (hisPets != null) {
				for (MmochatPet pet : hisPets) {
					if (pet != null) {
						sendMan.addPet(pet);
					}
				}
			}

			if (myPets != null) {
				for (MmochatPet pet : myPets) {
					if (pet != null) {
						firstMan.addPet(pet);
					}
				}
			}
		}

		// 5、设置双方的交易ID为未交易状态ID
		if (firstMan != null && sendMan != null) {
			firstMan.setDealId(0);
			sendMan.setDealId(0);
		}

		// 6、更新包裹金钱
		if (firstMan != null && sendMan != null) {
			Mmochat_5_31S pack = new Mmochat_5_31S();
			pack.setSmallMoney((int) firstMan.getSmall_money());
			MmochatUtil.sendCommonPack(firstMan, pack);

			pack.setSmallMoney((int) sendMan.getSmall_money());
			MmochatUtil.sendCommonPack(sendMan, pack);
		}
	}

	// 交易完成后的处理
	public void finishDeal() {
		dealState = MmochatDealState.交易完成;
		for (MmochatDealPackage pack : readyTodealMap.values()) {
			pack.stopDeal();
		}
		readyTodealMap.clear();
		dealedMap.clear();
		dealedPetMap.clear();
		MmochatDealService.deals.remove(id);
	}

	public Map<Integer, List<MmochatCommonObject>> getDealedMap() {
		return dealedMap;
	}

	public void setDealedMap(Map<Integer, List<MmochatCommonObject>> dealedMap) {
		this.dealedMap = dealedMap;
	}

	// 增加已交易出去的物品列表；这里givenRoleId是给出方的roleId
	public void addMyGivenObj(int givenRoleId, MmochatCommonObject obj) {
		if (obj == null || obj.getOverlapNum() == 0) {
			return;
		}
		List<MmochatCommonObject> myList = dealedMap.get(givenRoleId);
		if (myList != null) {
			myList.add(obj);
		}
	}

	public Map<Integer, List<MmochatPet>> getDealedPetMap() {
		return dealedPetMap;
	}

	public void setDealedPetMap(Map<Integer, List<MmochatPet>> dealedPetMap) {
		this.dealedPetMap = dealedPetMap;
	}

	// 增加已交易出去的宠物列表；这里givenRoleId是给出方的roleId
	public void addMyGivenPet(int givenRoleId, MmochatPet pet) {
		if (pet == null) {
			return;
		}
		List<MmochatPet> myList = dealedPetMap.get(givenRoleId);
		if (myList != null) {
			myList.add(pet);
		}
	}

}
